package com.cictec.middleware.commons.utils;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.Collection;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;

/**

 * 数字工具类<br>

 * 对于精确值计算应该使用 {@link BigDecimal}<br>

 * JDK7中<strong>BigDecimal(double val)</strong>构造方法的结果有一定的不可预知性，例如：

 * 

 * <pre>

 * new BigDecimal(0.1)

 * </pre>

 * 

 * 表示的不是<strong>0.1</strong>而是<strong>0.1000000000000000055511151231257827021181583404541015625</strong>

 * 

 * <p>

 * 这是因为0.1无法准确的表示为double。因此应该使用<strong>new BigDecimal(String)</strong>。

 * </p>

 * 相关介绍：

 * <ul>

 * <li>http://www.oschina.net/code/snippet_563112_25237</li>

 * <li>https://github.com/venusdrogon/feilong-core/wiki/one-jdk7-bug-thinking</li>

 * </ul>

 * 

 * @author Looly

 *

 */
public class NumberUtil {

	/** 默认除法运算精度 */
	private static final int DEFAUT_DIV_SCALE = 10;

	private NumberUtil() {
	}

	/**

	 * 提供精确的加法运算

	 * 

	 * @param v1 被加数

	 * @param v2 加数

	 * @return 和

	 */
	public static double add(double v1, double v2) {
		return add(Double.toString(v1), Double.toString(v2)).doubleValue();
	}
	
	/**

	 * 提供精确的加法运算

	 * @param v1 被加数

	 * @param v2 加数

	 * @return 和

	 * @since 3.0.8

	 */
	public static BigDecimal add(String v1, String v2) {
		final BigDecimal b1 = new BigDecimal(v1);
		final BigDecimal b2 = new BigDecimal(v2);
		return b1.add(b2);
	}

	/**

	 * 提供精确的减法运算

	 * 

	 * @param v1 被减数

	 * @param v2 减数

	 * @return 差

	 */
	public static double sub(double v1, double v2) {
		return sub(Double.toString(v1), Double.toString(v2)).doubleValue();
	}
	
	/**

	 * 提供精确的减法运算

	 * @param v1 被减数

	 * @param v2 减数

	 * @return 差

	 * @since 3.0.8

	 */
	public static BigDecimal sub(String v1, String v2) {
		final BigDecimal b1 = new BigDecimal(v1);
		final BigDecimal b2 = new BigDecimal(v2);
		return b1.subtract(b2);
	}

	/**

	 * 提供精确的乘法运算

	 * 

	 * @param v1 被乘数

	 * @param v2 乘数

	 * @return 积

	 */
	public static double mul(double v1, double v2) {
		return mul(Double.toString(v1), Double.toString(v2)).doubleValue();
	}
	
	/**

	 * 提供精确的乘法运算

	 * 

	 * @param v1 被乘数

	 * @param v2 乘数

	 * @return 积

	 * @since 3.0.8

	 */
	public static BigDecimal mul(String v1, String v2) {
		final BigDecimal b1 = new BigDecimal(v1);
		final BigDecimal b2 = new BigDecimal(v2);
		return b1.multiply(b2);
	}

	/**

	 * 提供(相对)精确的除法运算,当发生除不尽的情况的时候,精确到小数点后10位,后面的四舍五入

	 * 

	 * @param v1 被除数

	 * @param v2 除数

	 * @return 两个参数的商

	 */
	public static double div(double v1, double v2) {
		return div(v1, v2, DEFAUT_DIV_SCALE);
	}
	
	/**

	 * 提供(相对)精确的除法运算,当发生除不尽的情况的时候,精确到小数点后10位,后面的四舍五入

	 * 

	 * @param v1 被除数

	 * @param v2 除数

	 * @return 两个参数的商

	 */
	public static BigDecimal div(String v1, String v2) {
		return div(v1, v2, DEFAUT_DIV_SCALE);
	}

	/**

	 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入

	 * 

	 * @param v1 被除数

	 * @param v2 除数

	 * @param scale 精确度，如果为负值，取绝对值

	 * @return 两个参数的商

	 */
	public static double div(double v1, double v2, int scale) {
		return div(v1, v2, scale, RoundingMode.HALF_UP);
	}
	
	/**

	 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入

	 * 

	 * @param v1 被除数

	 * @param v2 除数

	 * @param scale 精确度，如果为负值，取绝对值

	 * @return 两个参数的商

	 */
	public static BigDecimal div(String v1, String v2, int scale) {
		return div(v1, v2, scale, RoundingMode.HALF_UP);
	}

	/**

	 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度

	 * 

	 * @param v1 被除数

	 * @param v2 除数

	 * @param scale 精确度，如果为负值，取绝对值

	 * @param roundingMode 保留小数的模式 {@link RoundingMode}

	 * @return 两个参数的商

	 */
	public static double div(double v1, double v2, int scale, RoundingMode roundingMode) {
		return div(Double.toString(v1), Double.toString(v2), scale, roundingMode).doubleValue();
	}
	
	/**

	 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度

	 * 

	 * @param v1 被除数

	 * @param v2 除数

	 * @param scale 精确度，如果为负值，取绝对值

	 * @param roundingMode 保留小数的模式 {@link RoundingMode}

	 * @return 两个参数的商

	 */
	public static BigDecimal div(String v1, String v2, int scale, RoundingMode roundingMode) {
		if (scale < 0) {
			scale = -scale;
		}
		final BigDecimal b1 = new BigDecimal(v1);
		final BigDecimal b2 = new BigDecimal(v2);
		return b1.divide(b2, scale, roundingMode);
	}

	// ------------------------------------------------------------------------------------------- round

	/**

	 * 保留固定位数小数<br>

	 * 采用四舍五入策略 {@link RoundingMode#HALF_UP}<br>

	 * 例如保留2位小数：123.456789 =》 123.46

	 * 

	 * @param v 值

	 * @param scale 保留小数位数

	 * @return 新值

	 */
	public static double round(double v, int scale) {
		return round(v, scale, RoundingMode.HALF_UP);
	}

	/**

	 * 保留固定位数小数<br>

	 * 采用四舍五入策略 {@link RoundingMode#HALF_UP}<br>

	 * 例如保留2位小数：123.456789 =》 123.46

	 * 

	 * @param numberStr 数字值的字符串表现形式

	 * @param scale 保留小数位数

	 * @return 新值

	 */
	public static double round(String numberStr, int scale) {
		return round(numberStr, scale, RoundingMode.HALF_UP);
	}

	/**

	 * 保留固定位数小数<br>

	 * 例如保留四位小数：123.456789 =》 123.4567

	 * 

	 * @param v 值

	 * @param scale 保留小数位数

	 * @param roundingMode 保留小数的模式 {@link RoundingMode}

	 * @return 新值

	 */
	public static double round(double v, int scale, RoundingMode roundingMode) {
		return round(Double.toString(v), scale, roundingMode);
	}

	/**

	 * 保留固定位数小数<br>

	 * 例如保留四位小数：123.456789 =》 123.4567

	 * 

	 * @param numberStr 数字值的字符串表现形式

	 * @param scale 保留小数位数

	 * @param roundingMode 保留小数的模式 {@link RoundingMode}

	 * @return 新值

	 */
	public static double round(String numberStr, int scale, RoundingMode roundingMode) {
		final BigDecimal b = new BigDecimal(numberStr);
		return b.setScale(scale, roundingMode).doubleValue();
	}

	/**

	 * 保留小数位，采用四舍五入

	 * 

	 * @param number 被保留小数的数字

	 * @param digit 保留的小数位数

	 * @return 保留小数后的字符串

	 */
	public static String roundStr(double number, int digit) {
		return String.format("%." + digit + 'f', number);
	}

	// ------------------------------------------------------------------------------------------- decimalFormat

	/**

	 * 格式化double<br>

	 * 对 {@link DecimalFormat} 做封装<br>

	 * 

	 * @param pattern 格式 格式中主要以 # 和 0 两种占位符号来指定数字长度。0 表示如果位数不足则以 0 填充，# 表示只要有可能就把数字拉上这个位置。<br>

	 *            <ul>

	 *            <li>0 =》 取一位整数</li>

	 *            <li>0.00 =》 取一位整数和两位小数</li>

	 *            <li>00.000 =》 取两位整数和三位小数</li>

	 *            <li># =》 取所有整数部分</li>

	 *            <li>#.##% =》 以百分比方式计数，并取两位小数</li>

	 *            <li>#.#####E0 =》 显示为科学计数法，并取五位小数</li>

	 *            <li>,### =》 每三位以逗号进行分隔，例如：299,792,458</li>

	 *            <li>光速大小为每秒,###米 =》 将格式嵌入文本</li>

	 *            </ul>

	 * @param value 值

	 * @return 格式化后的值

	 */
	public static String decimalFormat(String pattern, double value) {
		return new DecimalFormat(pattern).format(value);
	}

	/**

	 * 格式化double<br>

	 * 对 {@link DecimalFormat} 做封装<br>

	 * 

	 * @param pattern 格式 格式中主要以 # 和 0 两种占位符号来指定数字长度。0 表示如果位数不足则以 0 填充，# 表示只要有可能就把数字拉上这个位置。<br>

	 *            <ul>

	 *            <li>0 =》 取一位整数</li>

	 *            <li>0.00 =》 取一位整数和两位小数</li>

	 *            <li>00.000 =》 取两位整数和三位小数</li>

	 *            <li># =》 取所有整数部分</li>

	 *            <li>#.##% =》 以百分比方式计数，并取两位小数</li>

	 *            <li>#.#####E0 =》 显示为科学计数法，并取五位小数</li>

	 *            <li>,### =》 每三位以逗号进行分隔，例如：299,792,458</li>

	 *            <li>光速大小为每秒,###米 =》 将格式嵌入文本</li>

	 *            </ul>

	 * @param value 值

	 * @return 格式化后的值

	 * @since 3.0.5

	 */
	public static String decimalFormat(String pattern, long value) {
		return new DecimalFormat(pattern).format(value);
	}

	// ------------------------------------------------------------------------------------------- isXXX

	/**

	 * 是否为数字

	 * 

	 * @param str 字符串值

	 * @return 是否为数字

	 */
	public static boolean isNumber(String str) {
		
		if (PMSUtils.isEmpty(str)) {
			return false;
		}
		char[] chars = str.toCharArray();
		int sz = chars.length;
		boolean hasExp = false;
		boolean hasDecPoint = false;
		boolean allowSigns = false;
		boolean foundDigit = false;
		// deal with any possible sign up front

		int start = (chars[0] == '-') ? 1 : 0;
		if (sz > start + 1) {
			if (chars[start] == '0' && chars[start + 1] == 'x') {
				int i = start + 2;
				if (i == sz) {
					return false; // str == "0x"

				}
				// checking hex (it can't be anything else)

				for (; i < chars.length; i++) {
					if ((chars[i] < '0' || chars[i] > '9') && (chars[i] < 'a' || chars[i] > 'f') && (chars[i] < 'A' || chars[i] > 'F')) {
						return false;
					}
				}
				return true;
			}
		}
		sz--; // don't want to loop to the last char, check it afterwords

				// for type qualifiers

		int i = start;
		// loop to the next to last char or to the last char if we need another digit to

		// make a valid number (e.g. chars[0..5] = "1234E")

		while (i < sz || (i < sz + 1 && allowSigns && !foundDigit)) {
			if (chars[i] >= '0' && chars[i] <= '9') {
				foundDigit = true;
				allowSigns = false;

			} else if (chars[i] == '.') {
				if (hasDecPoint || hasExp) {
					// two decimal points or dec in exponent

					return false;
				}
				hasDecPoint = true;
			} else if (chars[i] == 'e' || chars[i] == 'E') {
				// we've already taken care of hex.

				if (hasExp) {
					// two E's

					return false;
				}
				if (!foundDigit) {
					return false;
				}
				hasExp = true;
				allowSigns = true;
			} else if (chars[i] == '+' || chars[i] == '-') {
				if (!allowSigns) {
					return false;
				}
				allowSigns = false;
				foundDigit = false; // we need a digit after the E

			} else {
				return false;
			}
			i++;
		}
		if (i < chars.length) {
			if (chars[i] >= '0' && chars[i] <= '9') {
				// no type qualifier, OK

				return true;
			}
			if (chars[i] == 'e' || chars[i] == 'E') {
				// can't have an E at the last byte

				return false;
			}
			if (chars[i] == '.') {
				if (hasDecPoint || hasExp) {
					// two decimal points or dec in exponent

					return false;
				}
				// single trailing decimal point after non-exponent is ok

				return foundDigit;
			}
			if (!allowSigns && (chars[i] == 'd' || chars[i] == 'D' || chars[i] == 'f' || chars[i] == 'F')) {
				return foundDigit;
			}
			if (chars[i] == 'l' || chars[i] == 'L') {
				// not allowing L with an exponent

				return foundDigit && !hasExp;
			}
			// last character is illegal

			return false;
		}
		// allowSigns is true iff the val ends in 'E'

		// found digit it to make sure weird stuff like '.' and '1E-' doesn't pass

		return !allowSigns && foundDigit;
	}

	/**

	 * 判断String是否是整数

	 * 

	 * @param s String

	 * @return 是否为整数

	 */
	public static boolean isInteger(String s) {
		if (!PMSUtils.isEmpty(s))
			return s.matches("^\\d+$");
		else
			return false;
	}

	/**

	 * 判断字符串是否是浮点数

	 * 

	 * @param s String

	 * @return 是否为{@link Double}类型

	 */
	public static boolean isDouble(String s) {
		try {
			Double.parseDouble(s);
			if (s.contains(".")) return true;
			return false;
		} catch (NumberFormatException e) {
			return false;
		}
	}

	/**

	 * 是否是质数<br>

	 * 质数表的质数又称素数。指整数在一个大于1的自然数中,除了1和此整数自身外,没法被其他自然数整除的数。

	 * 

	 * @param n 数字

	 * @return 是否是质数

	 */
	public static boolean isPrimes(int n) {
		for (int i = 2; i <= Math.sqrt(n); i++) {
			if (n % i == 0) {
				return false;
			}
		}
		return true;
	}

	// ------------------------------------------------------------------------------------------- generateXXX


	/**

	 * 生成不重复随机数 根据给定的最小数字和最大数字，以及随机数的个数，产生指定的不重复的数组

	 * 

	 * @param begin 最小数字（包含该数）

	 * @param end 最大数字（不包含该数）

	 * @param size 指定产生随机数的个数

	 * @return 随机int数组

	 */
	public static int[] generateRandomNumber(int begin, int end, int size) {
		if (begin > end) {
			int temp = begin;
			begin = end;
			end = temp;
		}
		// 加入逻辑判断，确保begin<end并且size不能大于该表示范围

		if ((end - begin) < size) {
			try {
				throw new Exception("Size is larger than range between begin and end!");
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		// 种子你可以随意生成，但不能重复

		int[] seed = new int[end - begin];

		for (int i = begin; i < end; i++) {
			seed[i - begin] = i;
		}
		int[] ranArr = new int[size];
		Random ran = new Random();
		// 数量你可以自己定义。

		for (int i = 0; i < size; i++) {
			// 得到一个位置

			int j = ran.nextInt(seed.length - i);
			// 得到那个位置的数值

			ranArr[i] = seed[j];
			// 将最后一个未用的数字放到这里

			seed[j] = seed[seed.length - 1 - i];
		}
		return ranArr;
	}

	/**

	 * 生成不重复随机数 根据给定的最小数字和最大数字，以及随机数的个数，产生指定的不重复的数组

	 * 

	 * @param begin 最小数字（包含该数）

	 * @param end 最大数字（不包含该数）

	 * @param size 指定产生随机数的个数

	 * @return 随机int数组

	 */
	public static Integer[] generateBySet(int begin, int end, int size) {
		if (begin > end) {
			int temp = begin;
			begin = end;
			end = temp;
		}
		// 加入逻辑判断，确保begin<end并且size不能大于该表示范围

		if ((end - begin) < size) {
			try {
				throw new Exception("Size is larger than range between begin and end!");
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

		Random ran = new Random();
		Set<Integer> set = new HashSet<Integer>();
		while (set.size() < size) {
			set.add(begin + ran.nextInt(end - begin));
		}

		Integer[] ranArr = set.toArray(new Integer[size]);
		return ranArr;
	}

	// ------------------------------------------------------------------------------------------- range

	/**

	 * 给定范围内的整数列表，步进为1

	 * 

	 * @param start 开始（包含）

	 * @param stop 结束（包含）

	 * @return 整数列表

	 */
	public static int[] range(int start, int stop) {
		return range(start, stop, 1);
	}

	/**

	 * 给定范围内的整数列表

	 * 

	 * @param start 开始（包含）

	 * @param stop 结束（包含）

	 * @param step 步进

	 * @return 整数列表

	 */
	public static int[] range(int start, int stop, int step) {
		if (start < stop) {
			step = Math.abs(step);
		} else if (start > stop) {
			step = -Math.abs(step);
		} else {// start == end

			return new int[] { start };
		}

		int size = Math.abs((stop - start) / step) + 1;
		int[] values = new int[size];
		int index = 0;
		for (int i = start; (step > 0) ? i <= stop : i >= stop; i += step) {
			values[index] = i;
			index++;
		}
		return values;
	}

	/**

	 * 将给定范围内的整数添加到已有集合中，步进为1

	 * 

	 * @param start 开始（包含）

	 * @param stop 结束（包含）

	 * @param values 集合

	 * @return 集合

	 */
	public static Collection<Integer> appendRange(int start, int stop, Collection<Integer> values) {
		return appendRange(start, stop, 1, values);
	}

	/**

	 * 将给定范围内的整数添加到已有集合中

	 * 

	 * @param start 开始（包含）

	 * @param stop 结束（包含）

	 * @param step 步进

	 * @param values 集合

	 * @return 集合

	 */
	public static Collection<Integer> appendRange(int start, int stop, int step, Collection<Integer> values) {
		if (start < stop) {
			step = Math.abs(step);
		} else if (start > stop) {
			step = -Math.abs(step);
		} else {// start == end

			values.add(start);
			return values;
		}

		for (int i = start; (step > 0) ? i <= stop : i >= stop; i += step) {
			values.add(i);
		}
		return values;
	}

	// ------------------------------------------------------------------------------------------- others

	/**

	 * 阶乘：n!

	 * 

	 * @param n 值

	 * @return 阶乘

	 */
	public static int factorial(int n) {
		if (n == 1) {
			return 1;
		}
		return n * factorial(n - 1);
	}

	/**

	 * 平方根算法<br>

	 * 推荐使用 {@link Math#sqrt(double)}

	 * 

	 * @param x 值

	 * @return 平方根

	 */
	public static long sqrt(long x) {
		long y = 0;
		long b = (~Long.MAX_VALUE) >>> 1;
		while (b > 0) {
			if (x >= y + b) {
				x -= y + b;
				y >>= 1;
				y += b;
			} else {
				y >>= 1;
			}
			b >>= 2;
		}
		return y;
	}

	/**

	 * 可以用于计算双色球、大乐透注数的方法<br>

	 * 比如大乐透35选5可以这样调用processMultiple(7,5); 就是数学中的：C75=7*6/2*1

	 * 

	 * @param selectNum 选中小球个数

	 * @param minNum 最少要选中多少个小球

	 * @return 注数

	 */
	public static int processMultiple(int selectNum, int minNum) {
		int result;
		result = mathSubnode(selectNum, minNum) / mathNode(selectNum - minNum);
		return result;
	}

	/**

	 * 最大公约数

	 * 

	 * @param m 第一个值

	 * @param n 第二个值

	 * @return 最大公约数

	 */
	public static int divisor(int m, int n) {
		while (m % n != 0) {
			int temp = m % n;
			m = n;
			n = temp;
		}
		return n;
	}

	/**

	 * 最小公倍数

	 * 

	 * @param m 第一个值

	 * @param n 第二个值

	 * @return 最小公倍数

	 */
	public static int multiple(int m, int n) {
		return m * n / divisor(m, n);
	}

	/**

	 * 获得数字对应的二进制字符串

	 * 

	 * @param number 数字

	 * @return 二进制字符串

	 */
	public static String getBinaryStr(Number number) {
		if (number instanceof Long) {
			return Long.toBinaryString((Long) number);
		} else if (number instanceof Integer) {
			return Integer.toBinaryString((Integer) number);
		} else {
			return Long.toBinaryString(number.longValue());
		}
	}

	/**

	 * 二进制转int

	 * 

	 * @param binaryStr 二进制字符串

	 * @return int

	 */
	public static int binaryToInt(String binaryStr) {
		return Integer.parseInt(binaryStr, 2);
	}

	/**

	 * 二进制转long

	 * 

	 * @param binaryStr 二进制字符串

	 * @return long

	 */
	public static long binaryToLong(String binaryStr) {
		return Long.parseLong(binaryStr, 2);
	}

	// ------------------------------------------------------------------------------------------- compare


	/**

	 * 比较两个值的大小

	 * 

	 * @see Character#compare(char, char)

	 * 

	 * @param x 第一个值

	 * @param y 第二个值

	 * @return x==y返回0，x&lt;y返回-1，x&gt;y返回1

	 * @since 3.0.1

	 */
	public static int compare(char x, char y) {
		return x - y;
	}

	/**

	 * 比较两个值的大小

	 * 

	 * @see Double#compare(double, double)

	 * 

	 * @param x 第一个值

	 * @param y 第二个值

	 * @return x==y返回0，x&lt;y返回-1，x&gt;y返回1

	 * @since 3.0.1

	 */
	public static int compare(double x, double y) {
		return Double.compare(x, y);
	}

	/**

	 * 比较两个值的大小

	 * 

	 * @see Integer#compare(int, int)

	 * 

	 * @param x 第一个值

	 * @param y 第二个值

	 * @return x==y返回0，x&lt;y返回-1，x&gt;y返回1

	 * @since 3.0.1

	 */
	public static int compare(int x, int y) {
		if (x == y) {
			return 0;
		}
		if (x < y) {
			return -1;
		} else {
			return 1;
		}
	}

	/**

	 * 比较两个值的大小

	 * 

	 * @see Long#compare(long, long)

	 * 

	 * @param x 第一个值

	 * @param y 第二个值

	 * @return x==y返回0，x&lt;y返回-1，x&gt;y返回1

	 * @since 3.0.1

	 */
	public static int compare(long x, long y) {
		if (x == y) {
			return 0;
		}
		if (x < y) {
			return -1;
		} else {
			return 1;
		}
	}

	/**

	 * 比较两个值的大小

	 * 

	 * @see Short#compare(short, short)

	 * 

	 * @param x 第一个值

	 * @param y 第二个值

	 * @return x==y返回0，x&lt;y返回-1，x&gt;y返回1

	 * @since 3.0.1

	 */
	public static int compare(short x, short y) {
		if (x == y) {
			return 0;
		}
		if (x < y) {
			return -1;
		} else {
			return 1;
		}
	}

	/**

	 * 比较两个值的大小

	 * 

	 * @see Byte#compare(byte, byte)

	 * 

	 * @param x 第一个值

	 * @param y 第二个值

	 * @return x==y返回0，x&lt;y返回-1，x&gt;y返回1

	 * @since 3.0.1

	 */
	public static int compare(byte x, byte y) {
		return x - y;
	}

	/**

	 * 数字转字符串<br>

	 * 调用{@link Number#toString()}，并去除尾小数点儿后多余的0

	 *

	 * @param number A Number

	 * @return A String.

	 */
	public static String toStr(Number number) {
		if (number == null) {
			throw new NullPointerException("Number is null !");
		}

		if (false == isValidIfNumber(number)) {
			throw new IllegalArgumentException("Number is non-finite!");
		}

		// 去掉小数点儿后多余的0

		String string = number.toString();
		if (string.indexOf('.') > 0 && string.indexOf('e') < 0 && string.indexOf('E') < 0) {
			while (string.endsWith("0")) {
				string = string.substring(0, string.length() - 1);
			}
			if (string.endsWith(".")) {
				string = string.substring(0, string.length() - 1);
			}
		}
		return string;
	}

	/**

	 * 检查是否为有效的数字<br>

	 * 检查Double和Float是否为无限大，或者Not a Number<br>

	 * 非数字类型和Null将返回true

	 * 

	 * @param obj 被检查类型

	 * @return 检查结果，非数字类型和Null将返回true

	 */
	public static boolean isValidIfNumber(Object obj) {
		if (obj != null && obj instanceof Number) {
			if (obj instanceof Double) {
				if (((Double) obj).isInfinite() || ((Double) obj).isNaN()) {
					return false;
				}
			} else if (obj instanceof Float) {
				if (((Float) obj).isInfinite() || ((Float) obj).isNaN()) {
					return false;
				}
			}
		}
		return true;
	}
	
	/**

	 * 是否空白符<br>

	 * 空白符包括空格、制表符、全角空格和不间断空格<br>

	 * 

	 * @see Character#isWhitespace(int)

	 * @see Character#isSpaceChar(int)

	 * @param c 字符

	 * @return 是否空白符

	 * @since 3.0.6

	 */
	public static boolean isBlankChar(char c) {
		return isBlankChar((int) c);
	}

	/**

	 * 是否空白符<br>

	 * 空白符包括空格、制表符、全角空格和不间断空格<br>

	 * 

	 * @see Character#isWhitespace(int)

	 * @see Character#isSpaceChar(int)

	 * @param c 字符

	 * @return 是否空白符

	 * @since 3.0.6

	 */
	public static boolean isBlankChar(int c) {
		return Character.isWhitespace(c) || Character.isSpaceChar(c);
	}
	
	/**

	 * 计算等份个数

	 * @param total 总数

	 * @param part 每份的个数

	 * @return 分成了几份

	 * @since 3.0.6

	 */
	public static int count(int total, int part){
		return (total % part == 0) ? (total / part) : (total / part+1);
	}

	// ------------------------------------------------------------------------------------------- Private method start

	private static int mathSubnode(int selectNum, int minNum) {
		if (selectNum == minNum) {
			return 1;
		} else {
			return selectNum * mathSubnode(selectNum - 1, minNum);
		}
	}

	private static int mathNode(int selectNum) {
		if (selectNum == 0) {
			return 1;
		} else {
			return selectNum * mathNode(selectNum - 1);
		}
	}
	// ------------------------------------------------------------------------------------------- Private method end

}